package com.xframe.xdal.core.util.redis.command;

import com.xframe.xdal.core.util.StringUtil;
import com.xframe.xdal.core.util.redis.pool.IRedisPool;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.commands.JedisCommands;

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @Description: Set 和 SortedSet
 * @ClassName: GatherCommand
 * @Author: Lean.Liu
 * @CreateTime: 2023/4/14 16:00
 **/
public class GatherCommand {
    private IRedisPool pool = null;

    public GatherCommand(IRedisPool pool){
        this.pool = pool;
    }

    /**
     *将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略
     *
     * @param key   key
     * @param val   val
     * @return 成功返回 被添加到集合中的新元素的数量，不包括被忽略的元素。 失败返回 0
     */
    public Long sadd(String key, String... val) {
        if (StringUtil.isValueNull(key, val)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        Jedis jedis = (Jedis) pool.getResource();
        jedis.multi();
        try {
            return client.sadd(key, val);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回集合 key 的基数(集合中元素的数量)。
     *
     * @param key   key
     * @return 成功返回 集合的基数。当 key 不存在时，返回 0 。
     */
    public Long scard(String key) {
        if (StringUtil.isValueNull(key)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.scard(key);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 判断 member 元素是否集合 key 的成员。
     * @param key
     * @param member 指定元素
     * @return 如果 member 元素是集合的成员，返回 true 。
     * 如果 member 元素不是集合的成员，或 key 不存在，返回 false。
     */
    public Boolean sismember(String key, String member) {
        if (StringUtil.isValueNull(key, member)) {
            return false;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.sismember(key, member);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 移除并返回集合中的一个随机元素。
     * @param key
     * @return 被移除的随机元素。
     * 当 key 不存在或 key 是空集时，返回 null 。
     */
    public String spop(String key, String member) {
        if (StringUtil.isValueNull(key, member)) {
            return null;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.spop(key);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素。
     * @param key
     * @param count 返回个数
     * @return 只提供 key 参数时，返回一个元素；如果集合为空，返回 nil 。
     * 如果提供了 count 参数，那么返回一个数组；如果集合为空，返回空数组。
     */
    public List<String> srandmember(String key, int count) {
        if (StringUtil.isValueNull(key, count)) {
            return null;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.srandmember(key, count);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
     * @param key
     * @param member 移出的元素
     * @return 成功 被成功移除的元素的数量，不包括被忽略的元素。 失败0
     */
    public Long srem(String key, String... member) {
        if (StringUtil.isValueNull(key, member)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.srem(key, member);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中
     * @param key
     * @param score
     * @param member
     * @return 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。
     */
    public Long zadd(String key, double score, String member) {
        if (StringUtil.isValueNull(key, member)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zadd(key, score, member);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中
     * @param key
     * @param scoreMembers
     * @return 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。
     */
    public Long zadd(String key, Map<String, Double> scoreMembers) {
        if (StringUtil.isValueNull(key, scoreMembers)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zadd(key, scoreMembers);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回有序集 key 的基数。
     * @param key
     * @return 当 key 存在且是有序集类型时，返回有序集的基数。
     * 当 key 不存在时，返回 0 。
     */
    public Long zcard(String key) {
        if (StringUtil.isValueNull(key)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zcard(key);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
     * @param key
     * @param min 最小值
     * @param max  组大值
     * @return  score 值在 min 和 max 之间的成员的数量。
     */
    public Long zcount(String key, double min, double max) {
        if (StringUtil.isValueNull(key, min, max)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zcount(key, min, max);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
     * @param key
     * @param min 最小值
     * @param max  组大值
     * @return  score 值在 min 和 max 之间的成员的数量。
     */
    public Long zcount(String key, String min, String max) {
        if (StringUtil.isValueNull(key, min, max)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zcount(key, min, max);
        } finally {
            pool.close(client);
        }
    }

    /**
     *  为有序集 key 的成员 member 的 score 值加上增量 increment 。
     * @param key
     * @param increment 增加的值
     * @param member 成员
     * @return 成功member 成员的新 score 值，以字符串形式表示。 失败 0
     */
    public Double zincrby(String key, double increment, String member) {
        if (StringUtil.isValueNull(key, increment, member)) {
            return 0D;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zincrby(key, increment, member);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回有序集 key 中，指定区间内的成员。
     * 其中成员的位置按 score 值递增(从小到大)来排序。
     * @param key
     * @param start
     * @param stop
     * @return 成功 指定区间内，带有 score 值(可选)的有序集成员的列表
     */
    public Set<String> zrange(String key, long start, long stop) {
        if (StringUtil.isValueNull(key, start, stop)) {
            return null;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zrange(key, start, stop);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
     * 有序集成员按 score 值递增(从小到大)次序排列。
     * @param key
     * @param min 最小
     * @param max 最大
     * @return 指定区间内，带有 score 值(可选)的有序集成员的列表。
     */
    public Set<String> zrangebyscore(String key, double min, double max) {
        if (StringUtil.isValueNull(key, min, max)) {
            return null;
        }
        JedisCommands client = pool.getClient();
        try {

            return client.zrangeByScore(key, min, max);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
     * 有序集成员按 score 值递增(从小到大)次序排列。
     * @param key
     * @param min 最小
     * @param max 最大
     * @return 指定区间内，带有 score 值(可选)的有序集成员的列表。
     */
    public Set<String> zrangebyscore(String key, String min, String max) {
        if (StringUtil.isValueNull(key, min, max)) {
            return null;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zrangeByScore(key, min, max);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
     * @param key
     * @param member
     * @return 如果 member 是有序集 key 的成员，返回 member 的排名。
     * 如果 member 不是有序集 key 的成员，返回 0 。
     */
    public Long zrank(String key, String member) {
        if (StringUtil.isValueNull(key, member)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zrank(key, member);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
     * @param key
     * @param member 移出的成员
     * @return 被成功移除的成员的数量，不包括被忽略的成员。
     */
    public Long zrem(String key, String... member) {
        if (StringUtil.isValueNull(key, member)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {

            return client.zrem(key, member);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 移除有序集 key 中，指定排名(rank)区间内的所有成员。
     * @param key
     * @param start 开始
     * @param stop  结束
     * @return 被移除成员的数量。
     */
    public Long zremrangeByRank(String key, long start, long stop) {
        if (StringUtil.isValueNull(key, start, stop)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zremrangeByRank(key, start, stop);
        } finally {
            pool.close(client);
        }
    }


    /**
     * 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
     * @param key
     * @param min
     * @param max
     * @return  被移除成员的数量。
     */
    public Long zremrangeByRank(String key, double min, double max) {
        if (StringUtil.isValueNull(key, min, max)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zremrangeByScore(key, min, max);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
     * @param key
     * @param min
     * @param max
     * @return 被移除成员的数量。
     */
    public Long zremrangeByRank(String key, String min, String max) {
        if (StringUtil.isValueNull(key, min, max)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zremrangeByScore(key, min, max);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回有序集 key 中，指定区间内的成员。
     * @param key
     * @param start
     * @param stop
     * @return 指定区间内，带有 score 值(可选)的有序集成员的列表。
     */
    public Set<String> zrevrange(String key, long start, long stop) {
        if (StringUtil.isValueNull(key, start, stop)) {
            return null;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zrevrange(key, start, stop);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。
     * 有序集成员按 score 值递减(从大到小)的次序排列。
     * @param key
     * @param max
     * @param min
     * @return 指定区间内，带有 score 值(可选)的有序集成员的列表。
     */
    public Set<String> zrevrangeByScore(String key, double max, double min) {
        if (StringUtil.isValueNull(key, max, min)) {
            return null;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zrevrangeByScore(key, max, min);
        } finally {
            pool.close(client);
        }
    }

    /**
     * 返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。
     * 有序集成员按 score 值递减(从大到小)的次序排列。
     * @param key
     * @param max
     * @param min
     * @return 指定区间内，带有 score 值(可选)的有序集成员的列表。
     */
    public Set<String> zrevrangeByScore(String key, String max, String min) {
        if (StringUtil.isValueNull(key, max, min)) {
            return null;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zrevrangeByScore(key, max, min);
        } finally {
            pool.close(client);
        }
    }


    /**
     * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。
     * @param key
     * @param member
     * @return 如果 member 是有序集 key 的成员，返回 member 的排名。
     * 如果 member 不是有序集 key 的成员，返回 0 。
     */
    public Long zrevrank(String key, String member) {
        if (StringUtil.isValueNull(key, member)) {
            return 0L;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zrevrank(key, member);
        } finally {
            pool.close(client);
        }
    }

    /**
     *  返回有序集 key 中，成员 member 的 score 值。
     * @param key
     * @param member
     * @return member 成员的 score 值
     */
    public Double zscore(String key, String member) {
        if (StringUtil.isValueNull(key, member)) {
            return 0D;
        }
        JedisCommands client = pool.getClient();
        try {
            return client.zscore(key, member);
        } finally {
            pool.close(client);
        }
    }
}
